/*

dpmax[i][j]=编号[i,j]合并后的最大值
dpmin[i][j]=编号[i,j]合并后的最小值

if op[k] == +
    dpmax[i][j]=max(dpmax[i][k]+dpmax[k+1][j])
    dpmin[i][j]=min(dpmin[i][k]+dpmin[k+1][j])

else if op[k] == *
    dpmax[i][j]=max(dpmax[i][k]*dpmax[k+1][j],
                    dpmax[i][k]*dpmin[k+1][j],
                    dpmin[i][k]*dpmax[k+1][j],
                    dpmin[i][k]*dpmin[k+1][j])

    dpmin[i][j]=min(dpmax[i][k]*dpmax[k+1][j],
                    dpmax[i][k]*dpmin[k+1][j],
                    dpmin[i][k]*dpmax[k+1][j],
                    dpmin[i][k]*dpmin[k+1][j])

dpmax[i][j] = -1e9
dpmin[i][j] =  1e9

dp[i][i]=arr[i]

*/
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <istream>
#include <vector>
using ll = int64_t;

int main(){
    std::iostream::sync_with_stdio(false);
    std::cin.tie(nullptr);

    ll n;
    std::cin>>n;
    const ll add=0,mul=1;
    const ll n21=2*n+1;
    std::vector<std::vector<ll>> op(n*2+1,std::vector<ll>(2));
    for(ll i=1;i<=n;i++){
        char c;
        std::cin>>c;
        if(c=='t'){
            op[i][0]=add;
        }else{
            op[i][0]=mul;
        }
        std::cin>>op[i][1];
        op[i+n]=op[i];
    }
    std::vector<std::vector<ll>> dpmax,dpmin;
    dpmax.clear();
    dpmax.resize(n21,std::vector<ll>(n21,-1e9));
    dpmin.clear();
    dpmin.resize(n21,std::vector<ll>(n21,1e9));
    for(ll i=1;i<=2*n;i++){
        dpmax[i][i]=op[i][1];
        dpmin[i][i]=op[i][1];
    }
    for(ll len=2;len<=n;len++){
        for(ll i=1;i<=2*n-len;i++){
            ll j=i+len-1;
            for(ll k=i;k<j;k++){
                if(op[k+1][0]==add){ //注意是k+1
                    dpmax[i][j]=std::max(
                        dpmax[i][k]+dpmax[k+1][j],
                        dpmax[i][j]
                    );
                    dpmin[i][j]=std::min(
                        dpmin[i][k]+dpmin[k+1][j],
                        dpmin[i][j]
                    );
                }else{
                    dpmax[i][j]=std::max({
                        dpmax[i][j],
                        dpmax[i][k]*dpmax[k+1][j],
                        dpmin[i][k]*dpmin[k+1][j],
                        dpmax[i][k]*dpmin[k+1][j],
                        dpmin[i][k]*dpmax[k+1][j]
                    });
                    dpmin[i][j]=std::min({
                        dpmin[i][j],
                        dpmax[i][k]*dpmax[k+1][j],
                        dpmin[i][k]*dpmin[k+1][j],
                        dpmax[i][k]*dpmin[k+1][j],
                        dpmin[i][k]*dpmax[k+1][j]
                    });
                }
            }
        }
    }
    ll ans=-1e9;
    std::vector<ll> edgs;
    for(ll i=1;i<=n;i++){
        ll nans=dpmax[i][i+n-1];
        if(nans>ans){
            ans=nans;
            edgs.clear();
            edgs.push_back(i);
        }else if(nans==ans){
            edgs.push_back(i);
        }
    }
    std::cout<<ans<<"\n";
    for(ll i:edgs){
        std::cout<<i<<" ";
    }
    std::cout<<"\n";
}